#ifndef _MY_CONFIG__
#define _MY_CONFIG__
#include<mutex>
#include<string>
#include"util.hpp"
#include"jsoncpp/json/json.h"
#define CONFIG_FILE "./cloud.conf"
namespace cloud
{
    class Config
    {
    public:
        static Config* GetInstance()
        {

            if(_Instance==nullptr)
            {
                _mutex.lock();
                if(_Instance==nullptr)
                {
                    _Instance=new Config;
                }
                _mutex.unlock();
            }


            return _Instance;
        }

        int GetHotTime()
        {
            return _hot_time;
        }

        int GetServerPort()
        {
            return _server_port;
        }

        std::string GetServerIp()
        {
            return _server_ip;
        }

        std::string GetDownloadPrefix()
        {
            return _download_prefix;
        }

        std::string GetPackSuffix()
        {
            return _pack_suffix;
        }

        std::string GetPackDir()
        {
            return _pack_dir;
        }

        std::string GetBackDir()
        {
            return _back_dir;
        }

        std::string GetBackupFile()
        {
            return _backup_file;
        }

        

        Config(const Config&)=delete;
        Config& operator=(const Config&)=delete;

    private:
        Config()
        {
            ReadConfigFile();
        }

        bool ReadConfigFile()
        {
            FileUtil file(CONFIG_FILE);
            std::string body;
            if(file.GetContent(&body)==false)
            {
                std::cout<<"read config file error"<<std::endl;
                return false;
            }

            Json::Value root;
            if(JsonUtil::UnSerialize(body,&root)==false)
            {
                std::cout<<"parse config file failed"<<std::endl;
                return false;
            }

            _hot_time=root["hot_time"].asInt();
            _server_port=root["server_port"].asInt();
            _server_ip=root["server_ip"].asString();
            _download_prefix=root["download_prefix"].asString();
            _pack_suffix=root["pack_suffix"].asString();
            _pack_dir=root["pack_dir"].asString();
            _back_dir=root["back_dir"].asString();
            _backup_file=root["backup_file"].asString();

            return true;

        }
    private:
        int _hot_time;
        int _server_port;
        std::string _server_ip;
        std::string _download_prefix;
        std::string _pack_suffix;
        std::string _pack_dir;
        std::string _back_dir;
        std::string _backup_file;

    private:
        static std::mutex _mutex;
        static Config* _Instance;
    };

    Config* Config::_Instance=nullptr;
    std::mutex Config::_mutex;
}


#endif
